{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepONet_adv.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "machine_shape": "hm"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "nY1RmvevXrp9"
   },
   "source": [
    "import jax\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit, hessian\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.experimental.ode import odeint\n",
    "from jax.nn import relu, elu\n",
    "from jax.config import config\n",
    "from jax.ops import index_update, index\n",
    "from jax import lax\n",
    "from jax.flatten_util import ravel_pytree\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange, tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.interpolate import griddata\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ikWFHV5IX5lh"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u\n",
    "        self.y = y\n",
    "        self.s = s\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "R4tCyvLs7luG"
   },
   "source": [
    "# Define MLP\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply\n",
    "\n",
    "# Define modified MLP\n",
    "def modified_MLP(layers, activation=relu):\n",
    "  def xavier_init(key, d_in, d_out):\n",
    "      glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "      W = glorot_stddev * random.normal(key, (d_in, d_out))\n",
    "      b = np.zeros(d_out)\n",
    "      return W, b\n",
    "\n",
    "  def init(rng_key):\n",
    "      U1, b1 =  xavier_init(random.PRNGKey(12345), layers[0], layers[1])\n",
    "      U2, b2 =  xavier_init(random.PRNGKey(54321), layers[0], layers[1])\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          W, b = xavier_init(k1, d_in, d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return (params, U1, b1, U2, b2) \n",
    "\n",
    "  def apply(params, inputs):\n",
    "      params, U1, b1, U2, b2 = params\n",
    "      U = activation(np.dot(inputs, U1) + b1)\n",
    "      V = activation(np.dot(inputs, U2) + b2)\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = activation(np.dot(inputs, W) + b)\n",
    "          inputs = np.multiply(outputs, U) + np.multiply(1 - outputs, V) \n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply\n"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "4ckGVVDAYCB7"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = modified_MLP(branch_layers, activation=np.tanh)\n",
    "        self.trunk_init, self.trunk_apply = modified_MLP(trunk_layers, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=2000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        # Used to restore the trained model parameters\n",
    "        _, self.unravel_params = ravel_pytree(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "\n",
    "        # Loggers\n",
    "        self.loss_log = []\n",
    "        self.loss_bcs_log = []\n",
    "        self.loss_res_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, x, t):\n",
    "        branch_params, trunk_params = params\n",
    "        y = np.stack([x,t])\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return   outputs\n",
    "            \n",
    "    # Define PDE residual\n",
    "    def residual_net(self, params, u, x, t, ux):\n",
    "        s = self.operator_net(params, u, x, t)\n",
    "        s_t = grad(self.operator_net, argnums=3)(params, u, x, t)\n",
    "        s_x = grad(self.operator_net, argnums=2)(params, u, x, t)\n",
    "\n",
    "        res = s_t + ux * s_x \n",
    "        return res\n",
    "\n",
    "    # Define boundary loss\n",
    "    def loss_bcs(self, params, batch):\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - s_pred)**2)\n",
    "        return loss\n",
    "\n",
    "    # Define residual loss\n",
    "    def loss_res(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y  = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0, 0, 0))(params, u, y[:,0], y[:,1], y[:,2])\n",
    "        # Compute loss\n",
    "        loss = np.mean((pred)**2)\n",
    "        return loss   \n",
    "\n",
    "    # Define total loss\n",
    "    def loss(self, params, bcs_batch, res_batch):\n",
    "        loss_bcs = self.loss_bcs(params, bcs_batch)\n",
    "        loss_res = self.loss_res(params, res_batch)\n",
    "        loss = 100 * loss_bcs +  loss_res\n",
    "        return loss \n",
    "\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, bcs_batch, res_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, bcs_batch, res_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, bcs_dataset, res_dataset, nIter = 10000):\n",
    "        bcs_data = iter(bcs_dataset)\n",
    "        res_data = iter(res_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            # Fetch data\n",
    "            bcs_batch= next(bcs_data)\n",
    "            res_batch = next(res_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, bcs_batch, res_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, bcs_batch, res_batch)\n",
    "                loss_bcs_value = self.loss_bcs(params, bcs_batch)\n",
    "                loss_res_value = self.loss_res(params, res_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_bcs_log.append(loss_bcs_value)\n",
    "                self.loss_res_log.append(loss_res_value)\n",
    "\n",
    "                # Print losses\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_bcs' : loss_bcs_value, \n",
    "                                  'loss_physics': loss_res_value})\n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_res(self, params, U_star, Y_star):\n",
    "        r_pred = vmap(self.residual_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return r_pred"
   ],
   "execution_count": 26,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "EyGqzSnIv211"
   },
   "source": [
    "# Use double precision to generate data (due to GP sampling)\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "\n",
    "# Deinfe initial and boundary conditions for advection equation\n",
    "# IC: f(x, 0)  = sin(pi x)\n",
    "# BC: g(0, t) = sin (pi t / 2) \n",
    "f = lambda x: np.sin(np.pi * x)\n",
    "g = lambda t: np.sin(np.pi * t/2)\n",
    "\n",
    "# Advection solver \n",
    "def solve_CVC(key, gp_sample, Nx, Nt, m, P):\n",
    "    # Solve u_t + a(x) * u_x = 0\n",
    "    # Wendroff for a(x)=V(x) - min(V(x)+ + 1.0, u(x,0)=f(x), u(0,t)=g(t)  (f(0)=g(0))\n",
    "    xmin, xmax = 0, 1\n",
    "    tmin, tmax = 0, 1\n",
    "    \n",
    "    N = gp_sample.shape[0]\n",
    "    X = np.linspace(xmin, xmax, N)[:,None]\n",
    "    V = lambda x: np.interp(x, X.flatten(), gp_sample)\n",
    "\n",
    "    # Create grid\n",
    "    x = np.linspace(xmin, xmax, Nx)\n",
    "    t = np.linspace(tmin, tmax, Nt)\n",
    "    h = x[1] - x[0]\n",
    "    dt = t[1] - t[0]\n",
    "    lam = dt / h\n",
    "\n",
    "    # Compute advection velocity\n",
    "    v_fn = lambda x: V(x) - V(x).min() + 1.0\n",
    "    v =  v_fn(x)\n",
    "\n",
    "    # Initialize solution and apply initial & boundary conditions\n",
    "    u = np.zeros([Nx, Nt])\n",
    "    u = index_update(u, index[0, :], g(t))\n",
    "    u = index_update(u, index[:, 0], f(x))\n",
    "    \n",
    "    # Compute finite difference operators\n",
    "    a = (v[:-1] + v[1:]) / 2\n",
    "    k = (1 - a * lam) / (1 + a * lam)\n",
    "    K = np.eye(Nx - 1, k=0)\n",
    "    K_temp = np.eye(Nx - 1, k=0)\n",
    "    Trans = np.eye(Nx - 1, k=-1)\n",
    "    def body_fn_x(i, carry):\n",
    "        K, K_temp = carry\n",
    "        K_temp = (-k[:, None]) * (Trans @ K_temp)\n",
    "        K += K_temp\n",
    "        return K, K_temp\n",
    "    K, _ = lax.fori_loop(0, Nx-2, body_fn_x, (K, K_temp))\n",
    "    D = np.diag(k) + np.eye(Nx - 1, k=-1)\n",
    "    \n",
    "    def body_fn_t(i, u):\n",
    "        b = np.zeros(Nx - 1)\n",
    "        b = index_update(b, index[0], g(i * dt) - k[0] * g((i + 1) * dt))\n",
    "        u = index_update(u, index[1:, i + 1], K @ (D @ u[1:, i] + b))\n",
    "        return u\n",
    "    UU = lax.fori_loop(0, Nt-1, body_fn_t, u)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    xx = np.linspace(xmin, xmax, m)\n",
    "    u = v_fn(xx)\n",
    "    # Output sensor locations and measurements\n",
    "    idx = random.randint(key, (P,2), 0, max(Nx,Nt))\n",
    "    y = np.concatenate([x[idx[:,0]][:,None], t[idx[:,1]][:,None]], axis = 1)\n",
    "    s = UU[idx[:,0], idx[:,1]]\n",
    "\n",
    "    return (x, t, UU), (u, y, s)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, P, Q):\n",
    "\n",
    "    subkeys = random.split(key, 10)\n",
    "    # Generate a GP sample\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(xmin, xmax, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(subkeys[0], (N,)))\n",
    "\n",
    "    v_fn = lambda x: np.interp(x, X.flatten(), gp_sample)\n",
    "    u_fn = lambda x: v_fn(x) - v_fn(x).min() + 1.0\n",
    "\n",
    "    (x, t, UU), (u, y, s) = solve_CVC(subkeys[1], gp_sample, Nx, Nt, m, P)\n",
    "\n",
    "    x_bc1 = np.zeros((P // 2, 1))\n",
    "    x_bc2 = random.uniform(subkeys[2], shape = (P // 2, 1))\n",
    "    x_bcs = np.vstack((x_bc1, x_bc2))\n",
    "\n",
    "    t_bc1 = random.uniform(subkeys[3], shape = (P//2, 1))\n",
    "    t_bc2 = np.zeros((P//2, 1))\n",
    "    t_bcs = np.vstack([t_bc1, t_bc2])\n",
    "\n",
    "    u_train = np.tile(u, (P, 1))\n",
    "    y_train = np.hstack([x_bcs, t_bcs])\n",
    "\n",
    "    s_bc1 = g(t_bc1)\n",
    "    s_bc2 = f(x_bc2)\n",
    "    s_train =  np.vstack([s_bc1, s_bc2])\n",
    "\n",
    "    x_r = random.uniform(subkeys[4], shape=(Q,1), minval=xmin, maxval=xmax)\n",
    "    t_r = random.uniform(subkeys[5], shape=(Q,1), minval=tmin, maxval=tmax)\n",
    "    ux_r = u_fn(x_r)\n",
    "\n",
    "    u_r_train = np.tile(u, (Q,1))\n",
    "    y_r_train = np.hstack([x_r, t_r, ux_r])\n",
    "    s_r_train = np.zeros((Q, 1))\n",
    "    \n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train, s_r_train\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, Nx, Nt, P):\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(xmin, xmax, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    (x, t, UU), (u, y, s) = solve_CVC(key, gp_sample, Nx, Nt, m, P)\n",
    "\n",
    "    XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "    u_test = np.tile(u, (Nx*Nt,1))\n",
    "    y_test = np.hstack([XX.flatten()[:,None], TT.flatten()[:,None]])\n",
    "    s_test = UU.T.flatten()\n",
    "\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, P, Q):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(generate_one_training_data, (0, None, None))(keys, P, Q)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P,-1))\n",
    "    y_train = np.float32(y_train.reshape(N * P,-1))\n",
    "    s_train = np.float32(s_train.reshape(N * P,-1))\n",
    "\n",
    "    u_r_train = np.float32(u_r_train.reshape(N * Q,-1))\n",
    "    y_r_train = np.float32(y_r_train.reshape(N * Q,-1))\n",
    "    s_r_train = np.float32(s_r_train.reshape(N * Q,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, Nx, Nt, P):\n",
    "\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "\n",
    "    u_test, y_test, s_test = vmap(generate_one_test_data, (0, None, None, None))(keys, Nx, Nt, P)\n",
    "\n",
    "    u_test = np.float32(u_test.reshape(N * Nx * Nt,-1))\n",
    "    y_test = np.float32(y_test.reshape(N * Nx * Nt,-1))\n",
    "    s_test = np.float32(s_test.reshape(N * Nx * Nt,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, Nx, Nt, P):\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, Nx, Nt, P)\n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    error_s = np.linalg.norm(s_test - s_pred, 2) / np.linalg.norm(s_test, 2) \n",
    "    return error_s"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "s4o8uU971yfJ"
   },
   "source": [
    "key = random.PRNGKey(0)\n",
    "\n",
    "# GRF length scale\n",
    "length_scale = 0.2\n",
    "\n",
    "# Resolution of the solution\n",
    "Nx = 100\n",
    "Nt = 100\n",
    "\n",
    "# Computational domain\n",
    "xmin = 0.0\n",
    "xmax = 1.0\n",
    "\n",
    "tmin = 0.0\n",
    "tmax = 1.0\n",
    "\n",
    "N = 1000 # number of input samples\n",
    "m = Nx   # number of input sensors\n",
    "P_train = 200   # number of output sensors, 100 for each side \n",
    "Q_train = 2000  # number of collocation points for each input sample\n",
    "\n",
    "# Generate training data\n",
    "u_bcs_train, y_bcs_train, s_bcs_train, u_res_train, y_res_train, s_res_train = generate_training_data(key, N, P_train, Q_train)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZdbEC_IV5d8r"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 100, 100, 100, 100, 100, 100]\n",
    "trunk_layers =  [2, 100, 100, 100, 100, 100, 100]\n",
    "\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 27,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "FDVeE-dk6I35"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "bcs_dataset = DataGenerator(u_bcs_train, y_bcs_train, s_bcs_train, batch_size)\n",
    "res_dataset = DataGenerator(u_res_train, y_res_train, s_res_train, batch_size)"
   ],
   "execution_count": 9,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "RYb9vB0h7Kzl"
   },
   "source": [
    "# Train\n",
    "# Note: may meet OOM issue if use Colab. Please train this model on the server.  \n",
    "# model.train(bcs_dataset, res_dataset, nIter=300000)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "-dWSpPxko8tb"
   },
   "source": [
    "# params = model.get_params(model.opt_state)\n",
    "\n",
    "# Save the trained model\n",
    "# flat_params, _  = ravel_pytree(model.get_params(model.opt_state))\n",
    "# np.save('adv_params.npy', flat_params)\n",
    "# np.save('adv_loss_res.npy', model.loss_res_log)\n",
    "# np.save('adv_loss_bcs.npy', model.loss_bcs_log)\n",
    "\n",
    "# Restore the trained model\n",
    "flat_params = np.load('adv_params.npy')\n",
    "params = model.unravel_params(flat_params)"
   ],
   "execution_count": 32,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "E1M0cRJzt2yK",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "outputId": "a547cb18-8583-40e6-a422-27f68ab8b1a6"
   },
   "source": [
    "# loss_bcs_log = model.loss_bcs_log\n",
    "# loss_res_log = model.loss_res_log\n",
    "\n",
    "# Restore losses\n",
    "loss_bcs_log = np.load('adv_loss_bcs.npy')\n",
    "loss_res_log = np.load('adv_loss_res.npy')\n",
    "\n",
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "plt.plot(loss_bcs_log, lw=2, label='bcs')\n",
    "plt.plot(loss_res_log, lw=2, label='res')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 29,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RNMa1cRw3-px",
    "outputId": "52f7bc6a-91e3-476f-b77e-c5cb2153d1bb"
   },
   "source": [
    "# Test data over 100 random input samples\n",
    "N_test = 10 \n",
    "P_test = m  \n",
    "\n",
    "key_test = random.PRNGKey(7654321)\n",
    "subkeys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Compute test error\n",
    "error_list = []\n",
    "for k in range(10):\n",
    "    keys_test = random.split(subkeys_test[k], N_test)\n",
    "    error_s = vmap(compute_error, (0, None, None, None))(keys_test, Nx, Nt, P_test) \n",
    "    error_list.append(error_s)\n",
    "\n",
    "error = np.stack(error_list)\n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error.mean()))\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error.std()))"
   ],
   "execution_count": 33,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 2.39e-02\n",
      "std of relative L2 error of s: 7.88e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "p3LRs8QLlBOX",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "3fe705e3-1774-48b1-8d25-2f7aeaaaf89e"
   },
   "source": [
    "# Compute relative l2 error for one random input sample\n",
    "\n",
    "key = keys_test[1]\n",
    "length_scale= 0.2\n",
    "\n",
    "P_test = 100\n",
    "Nx = 200\n",
    "Nt = 200\n",
    "\n",
    "N_test = 1\n",
    "u_test, y_test, s_test = generate_test_data(key, N_test, Nx, Nt, P_test)\n",
    "\n",
    "# Predict\n",
    "s_pred = model.predict_s(params, u_test, y_test)\n",
    "\n",
    "# Evulate solution at a uniform grid\n",
    "x = np.linspace(0, 1, Nx)\n",
    "t = np.linspace(0, 1, Nt)\n",
    "XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "S_pred = griddata(y_test, s_pred.flatten(), (XX,TT), method='cubic')\n",
    "S_test = griddata(y_test, s_test.flatten(), (XX,TT), method='cubic')\n",
    "\n",
    "error = np.linalg.norm(S_pred - S_test) / np.linalg.norm(S_test) \n",
    "print('Relative l2 errpr: {:.3e}'.format(error))"
   ],
   "execution_count": 38,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Relative l2 errpr: 2.070e-02\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Q-cgu5PelCnw",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "outputId": "155342bf-6c9f-4fb8-e925-fac2919a48b4"
   },
   "source": [
    "# Visualization\n",
    "fig = plt.figure(figsize=(18,5))\n",
    "plt.subplot(1,3,1)\n",
    "plt.pcolor(XX,TT, S_test, cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Exact $s(x,t)$')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "plt.pcolor(XX,TT, S_pred, cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Predict $s(x,t)$')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.pcolor(XX,TT, S_pred - S_test, cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Absolute error')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 39,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "0MxM4feb-kqM"
   },
   "source": [],
   "execution_count": null,
   "outputs": []
  }
 ]
}
